SpringCloud

SpringCloud简介

分布式微服务架构的一站式解决方案,多种微服务架构技术的集合体，俗称微服务全家桶，集成了二十多种微服务架构技术

微服务：SpringBoot是一个个的微服务【支付、物流、仓储..】，每个服务运行在独立进程中，服务间采用轻量级的HTTP协议的RESTFulApi通信机制协作，每个服务围绕业务进行构建，能够被独立部署，这样的服务也被称为微服务，独立的一个SpringBoot开发的服务单元；

架构、技术经理考虑通盘；程序员考虑一个具体功能的落地

形象比喻：服务就是桌子上的每一个菜，SpringCloud就是桌子

1. SpringCLoud的功能

   • SpringCloud融合、协调、组装微服务，使分布式系统构建变得更加容易，提供以下针对分布式系统的服务功能

     • 微服务的服务注册与发现【Eureka、nacos】

     • 服务负载均衡和调用【RiBBON、Feign】

     • 服务熔断、降级【HyStrix】

     • 服务消息队列

     • 分布式配置中心【Config、nacos】

     • 服务网关【Zuul】

     • 服务监控

     • 全链路追踪

     • 自动化构建部署

     • 服务定时任务、调度操作

     • 服务开发【SpringBoot】

2. SpringCloud继承的分布式项目列表

   • SpringCloud Config：分布式配置中心和配置管理

     把配置文件放在远程服务器，几种话管理集群配置，支持本地存储，Git和Subversion

   • SpringCloud Bus：消息总线

     用于集群中传递状态变化【如配置文件变化】，与springCloud Config联合实现热部署

   • Eureka：云端服务发现【服务注册中心】，已经停止更新，现在用的是阿里巴巴的nacos

     基于REST的服务，定位服务，实现云端服务发现和故障转移

   • Hystrix：熔断器，容错管理工具

     通过熔断机制控制服务和第三方库的节点从而对延迟和故障提供强大的容错能力

   • Zuul：是在云平台上提供动态路由、监控、弹性、安全等边缘服务的框架

     相当于客户端访问服务器的所有请求的前门

   • Archaius：配置管理API

     提供动态类型化属性、线程安全配置操作、轮询框架、回调机制等功能

   • Consul：封装Consul操作

     Consul操作是服务发现与配置工具、可以与docker无缝集成

   • Spring Cloud Sleuth：日志收集工具包

     封装了Dapper、log-based追踪、Zipkin和Htrace操作，为SpringCloud应用实现分布式追踪方案

   • Spring Cloud Data Flow：大数据操作工具

     是一个混合计算模型，结合了流数据和批量数据的处理方式

   • SpringCloud Security：基于Spring Security的安全工具包

     为应用提供安全控制

   • Spring Cloud Zookeeper：操作Zookeeper的工具包

     用于使用Zookeeper方式的服务发现和配置管理

   • Spring Cloud Stream：数据流操作开发包

     封装了与redis、rabbit、kafka发送消息的功能

   • SpringCloud CLI

     可以以命令行的方式快速建立云组件

   • Ribbon：服务负载均衡与调度

     提供多种负载均衡策略，可配合服务发现和断路器使用

   • NetFlix Feign：是一种声明式、模板化的Http客户端

     可以实现服务间的相互调用

   • SpringCloud Task：

     提供云端计划任务管理、任务调度

   • Spring Cloud Connectors：

     便于云端应用【如数据库和消息代理服务】在各种PaaS平台链接后端

   • SpringCloud Cluster：提供leadership选举

     如Zookeeper、redis、Hazelcast、Consul等常见状态模式的抽象和实现

   • Spring Cloud Starter：SpringBoot方式的启动项目

     为SpringCloud提供开箱即用的依赖管理

   • SpringCloud For Cloud Foundry：通过OAuth2协议绑定服务到Cloud Foundry

     Cloud Foundry是VMvare推出的开源PaaS云平台

   • Turbine：聚合服务器发送事件流数据的一个工具

     用来监控集群下的Hystrix的metrics情况

3. 大厂微服务架构举例

   【京东】

   

   【阿里】

   

   【京东物流】

   

4. 常见服务类型

   

5. 主流微服务架构体系

   • 大框框中的是SpringCloud框架中的内容

     SpringCloud的底子是NETFLIX，Cloud的工作者就是NETFLIX工作组，被Spring收编了

   • 外部是第三方的微服务框架

   

SpringCloud版本

SpringBoot以数字作为版本，SpringCloud以伦敦地铁站英文大写首字母作为版本号【以A-Z依次递推形式迭代】

SpringBoot2对应SpringCloud H版

1. SpringBoot版本介绍

   • SpringBoot的git源码地址：https:github.com/spring-projects/spring-boot/releases/

   • SpringBoot2新特性：https:github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.0-Release-Notes

   • 自19年后SpringBoot2就已经发布稳定版本，支持Java8和Java9

   • SpringBoot的版本变更非常频繁

2. SpringCloud版本介绍

   • SpringCloud官网：htts://spring.io/projects/spring-cloud

   • Git源码地址：https:github.com/spring-projects/spring-cloud/releases/

   • SpringCloud发布内容基类到临界点或者重大BUG被解决后都会发布一个Service release版本，简称SRX版本【X表示数字，Greenwich.SR2就是SpringCloud发布的Greenwich版本的第二个SRX版本】

3. SpringBoot版本和SpringCloud版本对应关系

   SpringCloud会停止对较老版本的维护，IDEA在构建项目会根据官网当前支持的版本供用户进行选择，所以官方不支持的版本在IDEA是无法选择的，但是可以在pom.xml中进行修改

   版本对应信息网站：https://spring.io/projects/spring-cloud/#overview

   SpringCloud和SpringBoot的版本不对应会出现非常大的麻烦，所以一定要确定好，同时使用boot和cloud，boot需要照顾cloud的版本

   SpringCloud版本	SpringBoot版本
   2022.0.x aka Kilburn	3.0.x, 3.1.x (Starting with 2022.0.3)
   2021.0.x aka Jubilee	2.6.x, 2.7.x (Starting with 2021.0.3)
   2020.0.x aka Ilford	2.4.x, 2.5.x (Starting with 2020.0.3)
   Hoxton	2.2.x, 2.3.x (Starting with SR5)
   Greenwich	2.1.x
   Finchley	2.0.x
   Edgware	1.5.x

   • 可以通过SpringCloud提供的接口获取版本对应的详细信息：https://start.spring.io/actuator/info

     使用浏览器的JsonView插件会自动把json格式字符串转换成下列格式

     xxxxxxxxxx
     {
       "git": {
         "branch": "155e08d25081f81ecbda6cedcaf322f5ede79842",
         "commit": {
           "id": "155e08d",
           "time": "2023-10-17T15:00:04Z"
         }
       },
       "build": {
         "version": "0.0.1-SNAPSHOT",
         "artifact": "start-site",
         "versions": {
           "spring-boot": "3.1.4",
           "initializr": "0.21.0-SNAPSHOT"
         },
         "name": "start.spring.io website",
         "time": "2023-10-17T17:58:29.439Z",
         "group": "io.spring.start"
       },
       "bom-ranges": {
         "codecentric-spring-boot-admin": {
           "2.6.8": "Spring Boot >=2.6.0 and <2.7.0-M1",
           "2.7.4": "Spring Boot >=2.7.0-M1 and <3.0.0-M1",
           "3.0.4": "Spring Boot >=3.0.0-M1 and <3.1.0-M1",
           "3.1.5": "Spring Boot >=3.1.0-M1 and <3.2.0-M1"
         },
         "hilla": {
           "2.1.9": "Spring Boot >=3.1.0-M1 and <3.2.0-M1"
         },
         "sentry": {
           "6.28.0": "Spring Boot >=2.7.0 and <3.2.0-M1"
         },
         "solace-spring-boot": {
           "1.2.2": "Spring Boot >=2.6.0 and <3.0.0-M1",
           "2.0.0": "Spring Boot >=3.0.0-M1"
         },
         "solace-spring-cloud": {
           "2.3.2": "Spring Boot >=2.6.0 and <3.0.0-M1",
           "3.0.0": "Spring Boot >=3.0.0-M1"
         },
         "spring-cloud": {
           "2021.0.8": "Spring Boot >=2.6.0 and <3.0.0",
           "2022.0.4": "Spring Boot >=3.0.0 and <3.2.0-M1",
           "2023.0.0-M2": "Spring Boot >=3.2.0-M1 and <3.2.0-SNAPSHOT",
           "2023.0.0-SNAPSHOT": "Spring Boot >=3.2.0-SNAPSHOT"
         },
         "spring-cloud-azure": {
           "4.11.0": "Spring Boot >=2.6.0 and <3.0.0-M1",
           "5.5.0": "Spring Boot >=3.0.0-M1 and <3.2.0-M1"
         },
         "spring-cloud-gcp": {
           "3.7.1": "Spring Boot >=2.6.0 and <3.0.0-M1",
           "4.8.1": "Spring Boot >=3.0.0-M1 and <3.2.0-M1"
         },
         "spring-cloud-services": {
           "3.4.0": "Spring Boot >=2.6.0 and <2.7.0-M1",
           "3.5.0": "Spring Boot >=2.7.0-M1 and <3.0.0-M1",
           "4.0.3": "Spring Boot >=3.0.0 and <3.2.0-M1"
         },
         "spring-modulith": {
           "1.0.0": "Spring Boot >=3.1.0 and <3.2.0-M1",
           "1.1.0-M1": "Spring Boot >=3.2.0-M1"
         },
         "spring-shell": {
           "2.1.13": "Spring Boot >=2.7.0 and <3.0.0-M1",
           "3.0.8": "Spring Boot >=3.0.0 and <3.1.0-M1",
           "3.1.4": "Spring Boot >=3.1.0 and <3.2.0-M1",
           "3.2.0-M2": "Spring Boot >=3.2.0-M1"
         },
         "vaadin": {
           "23.2.15": "Spring Boot >=2.6.0 and <2.7.0-M1",
           "23.3.25": "Spring Boot >=2.7.0-M1 and <3.0.0-M1",
           "24.1.12": "Spring Boot >=3.0.0-M1 and <3.2.0-M1"
         },
         "wavefront": {
           "2.2.2": "Spring Boot >=2.6.0 and <2.7.0-M1",
           "2.3.4": "Spring Boot >=2.7.0-M1 and <3.0.0-M1",
           "3.0.2": "Spring Boot >=3.0.0-M1 and <3.1.0-M1"
         }
       },
       "dependency-ranges": {
         "okta": {
           "2.1.6": "Spring Boot >=2.6.0 and <3.0.0-M1",
           "3.0.5": "Spring Boot >=3.0.0-M1 and <3.2.0-M1"
         },
         "mybatis": {
           "2.2.2": "Spring Boot >=2.6.0 and <2.7.0-M1",
           "2.3.1": "Spring Boot >=2.7.0-M1 and <3.0.0-M1",
           "3.0.2": "Spring Boot >=3.0.0-M1"
         },
         "pulsar": {
           "0.2.0": "Spring Boot >=3.0.0 and <3.2.0-M3"
         },
         "pulsar-reactive": {
           "0.2.0": "Spring Boot >=3.0.0 and <3.2.0-M1"
         },
         "camel": {
           "3.14.9": "Spring Boot >=2.6.0 and <2.7.0-M1",
           "3.20.6": "Spring Boot >=2.7.0.M1 and <3.0.0-M1",
           "4.1.0": "Spring Boot >=3.0.0-M1 and <3.2.0-M1"
         },
         "picocli": {
           "4.7.4": "Spring Boot >=2.6.0 and <3.1.0-M1"
         }
       }
     }
     

4. demo版本保持和教程一致，避免不必要的麻烦

   框架	版本
   cloud	Hoxton.SR1
   boot	2.2.RELEASE
   cloud	alibaba 2.1.0.RELEASE
   java	Java8
   Maven	3.5及以上

5. SpringCloud的停更策略

   Nacos能替换掉原来SpringCloud中的服务注册中心、服务配置中心和消息总线，干翻了Eureka、Config和Bus

   • 停更不停用

     被动更新【不是致命bug不修】，git上的代码合并请求不受理，不再发布新版本

   • Cloud升级到H版的更新点

     • 服务注册中心

       停用Eureka【重度患者，进ICU】，可选的替代品有

       • Zookeeper【老系统用Dubbo做服务调用，Zookeeper很适合做老项目的服务注册中心替代Eureka】、

       • Consul【go语言实现的框架，不推荐使用】、

       • Nacos【经过百万级并发量考验，不仅能替换Eureka，还能替换其他一些组件，非常重要】

     • 负载均衡

       Ribbon停更了【轻度患者】，但是现行的版本还在使用，

       • Spring希望用LoadBalancer逐渐取代Ribbon

     • 服务调用

       最初做服务调用的Feign也几乎停用了

       • 现在的替代品是OpenFeign

     • 服务降级

       Hystrix，SpringCloud原生自带的熔断降级框架正在被大规模使用，但是官网不再使用

       其中的设计理念：服务熔断、服务降级、服务限流、服务隔离思想很值得借鉴

       • 国外现在使用广泛的替代品是resilience4j【4j表示for java】，但国内使用很少

       • 国内有望替换Hystrix的产品是SpringCloud Alibaba Sentinel【实现熔断和限流，非常好用】

     • 服务网关

       Zuul【服务网关作为总的服务接入口，做服务的协调、调度】，网飞的Zuul2没弄成，基本出不来

       • Spring自身出了Gateway作为Zuul的替代，现在使用也很广泛

     • 服务配置

       Config也停用了

       • 携程的阿波罗appollo还可以

       • 主流还是使用Nacos

     • 服务总线

       • 服务总线原生Bus消息总线也被Nacos替换

SpringCloud文档

最权威的就是官网上对应版本号的官方文档

1. 英文文档

   • https://cloud.spring.io/spring-cloud-static/Hoxton.SR1/reference/htmlsingle/

2. 中文文档

   • https://www.bookstack.cn/read/spring-cloud-docs/docs-index.md

3. 对应SpringBoot2.2.2的官方文档

   • https://docs.spring.io/spring-boot/docs/2.2.2.RELEASE/reference/htmlsingle/

微服务搭建

使用Mybatis+SpringBoot搭建订单-支付两个存在调用关系的微服务模块

1. 约定>配置>编码

   • 约定：Java规范、SQL语句规范、Git提交流程...

   • 配置：组件选型

   • 编码：业务组件落地

2. 创建父工程

   • 第一步，创建maven工程，页面原型选择site结尾的原型，maven不要选择IDEA默认的maven

   • 第二步，设置项目字符编码格式为UTF-8

     

   • 第三步，开启注解生效激活

     

     

   • 第四步，开启Java8编译

     

   • 第五步，选择fileType过滤，目录结构中不显示特定后缀名的文件【个人习惯，可以不设置】

     

3.设置父工程的pom.xml

删除父工程的src目录

dependencyManagement和dependencies的区别

• dependencyManagement：

  • 通常会在一个组织或者项目的最顶层的父POM中看到dependencyManagement

  • 能让所有在子项目中引用一个依赖而不用显示的列出版本号，Maven会沿着父子层次向上直到找到拥有dependencyManagement元素的项目，自动使用dependencyManagement元素中指定的版本号，

  • 好处是所有的子项目都是采用父容器规定的版本号，无需每个子版本都进行声明，子版本需要另外版本可以在子项目中单独声明

  • dependencyManagement只是声明依赖，并不会引入，子项目需要显示声明需要用到的依赖

  • 由于本机mysql的版本是mysql8.0.27，这里更改了mysql驱动的版本

• dependencies是真正的引入依赖，通常在子模块中使用

​x
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.atlisheng</groupId>
    <artifactId>cloud-h-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <!--统一管理jar包的版本-->
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!--老四件套-->
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
        <mysql.version>8.0.27</mysql.version>
        <!--mybatis和德鲁伊的版本号-->
        <druid.version>1.1.16</druid.version>
        <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
    </properties>

    <!--子模块继承后提供：锁定版本+子模块不用写groupId和version-->
    <dependencyManagement>
        <!--dependencyManagement和dependencies的区别
            dependencyManagement：通常会在一个组织或者项目的最顶层的父POM中看到dependencyManagement，
                    能让所有在子项目中引用一个依赖而不用显示的列出版本号，Maven会沿着父子层次向上直到找到拥有dependencyManagement元素的项目，自动使用
                    dependencyManagement元素中指定的版本号，好处是所有的子项目都是采用父容器规定的版本号，无需每个子版本都进行声明，子版本需要另外版本
                    可以在子项目中单独声明
                dependencyManagement只是声明依赖，并不会引入，子项目需要显示声明需要用到的依赖
                由于本机mysql的版本是mysql8.0.27，这里更改了mysql驱动的版本
            dependencies是真正的引入依赖，通常在子模块中使用
        -->
        <dependencies>
            <!--springboot 2.2.2-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.2.2.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--spring cloud Hoxton.SR1-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--spring cloud alibaba 2.1.0.RELEASE-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2.1.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.spring.boot.version}</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <optional>true</optional>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <!--plugin提示fork不可用,加一个和springboot一样的版本号，但是2.2.2RELEASE提示不存在，这里用最近的2.2.1-->
                <version>2.2.1.RELEASE</version>
                <configuration>
                    <fork>true</fork>
                    <addResources>true</addResources>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

【点击闪电掉过maven的测试阶段】

不知道有啥用，作用是跳过测试阶段，但是原因不清楚

编写业务

controller-service-dao-mysql

一个应用启动后在IDEA中的run空间，多个微服务开启后IDEA最好用的是run DashBoard，没有该功能需要开启，可以在finish中自动启动上次关闭的所有微服务，这个功能很强

• 新版本叫做services，点击Views--Tool Windows--services可以打开services窗口【或者快捷键alt+8】,默认界面不显示任何服务，需要配置add Configuration Type为SpringBoot，会自动导入正在运行的SpringBoot项目

• 也可以通过修改IDEA的.idea/workspace.xml的方式快速打开Run Dashboard窗口，替换掉workspace.xml下name为configurationTypes的整个option为以下内容，上一步操作成功该配置文件会自动出现该内容

  xxxxxxxxxx
  <component name="RunDashboard">
      <option name="configurationTypes">
          <set>
              <option value="SpringBootApplicationConfigurationType" />
          </set>
      </option>
  </component>
  

【创建子模块01-provider-payment】

【pom.xml】

xxxxxxxxxx
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>cloud-h-demo</artifactId>
        <groupId>com.atlisheng</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>01-provider-payment</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!--包含了sleuth+zipkin-->
        <!--<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>-->
        <!--eureka-client-->
        <!--<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--mysql-connector-java-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

1. 建数据库表

   使用cloud_h_demo作为数据库

   字段名必须用`包围，不能用单引号，否则报错

   xxxxxxxxxx
   CREATE TABLE `payment` (
   `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '自增主键',
   `serial` VARCHAR(200) DEFAULT '',
   PRIMARY KEY(`id`)
   )ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8
   

2. mybatis+springboot的基本业务结构

   • 业务结构总览

     

   • 启动类

     xxxxxxxxxx
     @SpringBootApplication
     public class PaymentApplication {
         public static void main(String[] args) {
             SpringApplication.run(PaymentApplication.class,args);
         }
     }
     

   • application.yml

     xxxxxxxxxx
     server:
       port: 8001
     spring:
       application:
         name: service-payment
       datasource:
         type: com.alibaba.druid.pool.DruidDataSource
         driver-class-name: com.mysql.cj.jdbc.Driver
         url: jdbc:mysql://localhost:3306/cloud_h_demo?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8&useSSL=false
         password: Haworthia0715
         username: root
     
     mybatis:
       mapper-locations: classpath:mapper/*.xml
       #所有entities所在的包
       type-aliases-package: com.atlisheng.cloud.entities
     

   • entity

     xxxxxxxxxx
     /**
      * @author Earl
      * @version 1.0.0
      * @描述 主实体：对应数据库中的payment表
      * 实现Serializable接口在分布式部署中可能用的上
      * @创建日期 2023/10/20
      * @since 1.0.0
      */
     @Data
     @AllArgsConstructor
     @NoArgsConstructor
     public class Payment implements Serializable {
         /**
          *主键，使用Long对应数据库表中的BIGINT
          */
         private Long id;
         /**
          *
          */
         private String serial;
     }
     

   • dao

     xxxxxxxxxx
     /**
      * @author Earl
      * @version 1.0.0
      * @描述 原则上各种增删改查的方法都要写上
      * @创建日期 2023/10/20
      * @since 1.0.0
      */
     @Mapper
     public interface PaymentDao {
         public int create(Payment payment);
         public Payment getPaymentById(@Param("id") Long id);
     }
     

   • mapper.xml

     xxxxxxxxxx
     <?xml version="1.0" encoding="UTF-8" ?>
     <!DOCTYPE mapper
             PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
             "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
     
     <!--指定映射哪个Dao接口-->
     <mapper namespace="com.atlisheng.cloud.dao.PaymentDao">
         <!--id对应映射的方法，
             parameterType="Payment"指定参数封装的entity实体类或者基本数据类型
             useGeneratedKeys="true" Mybatis 配置文件 useGeneratedKeys 参数只针对 insert 语句生效，默认为 false。当设置为
                 true 时，表示如果插入的表以自增列为主键，则允许 JDBC 支持自动生成主键，并可将自动生成的主键返回给实体类的对应属性。
             keyProperty="id"指定主键值赋值给对象的哪个属性，此处表示将主键值赋值给插值Payment对象的id属性
             -->
         <insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">
             insert into payment(serial) values (#{serial});
         </insert>
     
         <!--column:数据库字段名，property映射属性名，jdbcType：字段数据类型-->
         <resultMap id="BaseResultMap" type="com.atlisheng.cloud.entities.Payment">
             <id column="id" property="id" jdbcType="BIGINT"/>
             <id column="serial" property="serial" jdbcType="VARCHAR"/>
         </resultMap>
         <select id="getPaymentById" parameterType="Long" resultMap="BaseResultMap">
             select * from payment where id=#{id};
         </select>
     </mapper>
     

   • service

     【接口】

     xxxxxxxxxx
     public interface PaymentService {
         public int create(Payment payment);
         public Payment getPaymentById(@Param("id") Long id);
     }
     

     【实现类】

     xxxxxxxxxx
     @Service
     public class PaymentServiceImpl implements PaymentService {
         /**
          *Resource注解是java自带的，@Autowire是Spring自带的，使用@Resource也能实现自动注入
          * 由于@Mapper注解不是Spring自带的，使用Autowire注解Spring会认为不能注入从而标红，但是实际运行没有问题，
          * 在Dao上用@Component注解使用@Autowire就不会显示异常
          */
         @Resource
         private PaymentDao paymentDao;
     
         @Override
         public int create(Payment payment){
             return paymentDao.create(payment);
         }
     
         @Override
         public Payment getPaymentById(@Param("id") Long id){
             return paymentDao.getPaymentById(id);
         }
     }
     

   • 通用响应类

     xxxxxxxxxx
     /**
      * @author Earl
      * @version 1.0.0
      * @描述 通用返回类
      * @创建日期 2023/10/20
      * @since 1.0.0
      */
     @Data
     @AllArgsConstructor
     @NoArgsConstructor
     public class CommonResp<T> {
         //实际上响应码用枚举更加符合规范
         private Integer code;
         private String message;
         private T data;
     
         /**
          * @param code
          * @param message
          * @return
          * @描述 有参构造，还可以设置方法返回this达到链式变成的效果
          * @author Earl
          * @version 1.0.0
          * @创建日期 2023/10/20
          * @since 1.0.0
          */
         public CommonResp(Integer code,String message){
             this(code,message,null);
         }
     }
     

   • 前端控制器

     xxxxxxxxxx
     @RestController
     @Slf4j//用于日志打印，自动注入log对象
     public class PaymentController {
         @Autowired
         private PaymentService paymentService;
     
         @PostMapping("/payment/create")
         public CommonResp create(Payment payment){
             int result=paymentService.create(payment);
             log.info("插入结果："+result);
             return result>0?new CommonResp(200,"数据插入成功",result):
                     new CommonResp(505,"插入数据库失败");
         }
     
         @PostMapping("/payment/get/{id}")
         public CommonResp getPaymentById(@PathVariable Long id){
             Payment payment = paymentService.getPaymentById(id);
             log.info("查询结果："+payment);
             return payment!=null?new CommonResp(200,"查询成功",payment):
                     new CommonResp(505,"没有对应ID的记录"+id);
         }
     
     }
     

3. 测试

   分布式相关的配置需要注释掉，因为配置文件中确实部分配置，启动会报错

   测试插入记录和查询记录功能正常

DevTools热部署

代码改动以后自动生效，不需要再手动重启项目，热部署除了devtools还可以使用jrebel

1. 引入热部署

   • 第一步：引入devtools组件jar包

     xxxxxxxxxx
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-devtools</artifactId>
         <scope>runtime</scope>
         <optional>true</optional>
     </dependency>
     

   • 第二步：开启项目自动构建和编译

     

   • 第三步：快捷键shift+ctrl+alt+/打开Maintenance菜单的Registry，勾选下列两个选项

     

   • 第四步：重启IDEA

   • 效果：更新完不会立即重启，更新完再次发送请求时会立即重启再执行请求【这个老杜讲过，假热部署】

     • 这个配置只允许在开发阶段，生产环境这个功能必须关闭

创建第二个微服务

02-consumer-order

创模块--写pom--写yml--启动类--业务类

逻辑是订单服务对支付服务进行调用

1. 项目结构

   

   • pom.xml

     xxxxxxxxxx
     <?xml version="1.0" encoding="UTF-8"?>
     <project xmlns="http://maven.apache.org/POM/4.0.0"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
         <parent>
             <artifactId>cloud-h-demo</artifactId>
             <groupId>com.atlisheng</groupId>
             <version>1.0-SNAPSHOT</version>
         </parent>
         <modelVersion>4.0.0</modelVersion>
     
         <!--继承了父工程子模块就不用写ga坐标了-->
         <artifactId>02-consumer-order</artifactId>
     
         <properties>
             <maven.compiler.source>8</maven.compiler.source>
             <maven.compiler.target>8</maven.compiler.target>
         </properties>
     
         <dependencies>
             <!--包含了sleuth+zipkin-->
             <!--<dependency>
                 <groupId>org.springframework.cloud</groupId>
                 <artifactId>spring-cloud-starter-zipkin</artifactId>
             </dependency>-->
             <!--<dependency>
                 <groupId>org.springframework.cloud</groupId>
                 <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
             </dependency>-->
             <dependency>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-starter-web</artifactId>
             </dependency>
             <dependency>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-starter-actuator</artifactId>
             </dependency>
     
             <dependency>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-devtools</artifactId>
                 <scope>runtime</scope>
                 <optional>true</optional>
             </dependency>
             <dependency>
                 <groupId>org.projectlombok</groupId>
                 <artifactId>lombok</artifactId>
                 <optional>true</optional>
             </dependency>
             <dependency>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-starter-test</artifactId>
                 <scope>test</scope>
             </dependency>
         </dependencies>
     </project>
     

   • application.yml

     xxxxxxxxxx
     server:
       port: 80 #用户支付下订单的模块用户不应该关心输入哪个端口进行访问，浏览器网页服务的默认端口都是80，只需要输入网址，不需要输入:80,提升用户体验
     

   • config

     【ApplicationContextConfig】

     xxxxxxxxxx
     @Configuration
     public class ApplicationContextConfig {
         /**
          * @return {@link RestTemplate }
          * @描述 注入RestTemplate对象
          * @author Earl
          * @version 1.0.0
          * @创建日期 2023/10/20
          * @since 1.0.0
          */
         @Bean
         public RestTemplate getRestTemplate(){
             return new RestTemplate();
         }
     }
     

   • controller

     【OrderController】

     xxxxxxxxxx
     @RestController
     @Slf4j
     public class OrderController {
         public static final String PAYMENT_URL="http://localhost:8001";
     
         @Resource
         private RestTemplate restTemplate;
     
         /**
          * @param payment
          * @return {@link CommonResp }<{@link Payment }>
          * @描述 RestTemplate发送post请求对其他服务进行调用，参数以对象的形式传入
          * @author Earl
          * @version 1.0.0
          * @创建日期 2023/10/20
          * @since 1.0.0
          */
         @PostMapping("/consumer/payment/create")
         public CommonResp<Payment> create(Payment payment){
             return restTemplate.postForObject(PAYMENT_URL+"/payment/create",payment,CommonResp.class);
         }
     
         /**
          * @param id
          * @return {@link CommonResp }<{@link Payment }>
          * @描述 RestTemplate发送Get请求对其他服务进行调用，参数直接拼接在url尾部
          * @author Earl
          * @version 1.0.0
          * @创建日期 2023/10/20
          * @since 1.0.0
          */
         @GetMapping("/consumer/payment/get/{id}")
         public CommonResp<Payment> getPayment(@PathVariable Long id){
             return restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id,CommonResp.class);
         }
     }
     

   • entities

     【Payment】

     xxxxxxxxxx
     /**
      * @author Earl
      * @version 1.0.0
      * @描述 主实体：对应数据库中的payment表
      * 实现Serializable接口在分布式部署中可能用的上
      * @创建日期 2023/10/20
      * @since 1.0.0
      */
     @Data
     @AllArgsConstructor
     @NoArgsConstructor
     public class Payment implements Serializable {
         /**
          *主键，使用Long对应数据库表中的BIGINT
          */
         private Long id;
         /**
          *
          */
         private String serial;
     }
     

   • resp

     【CommonResp】

     xxxxxxxxxx
     /**
      * @author Earl
      * @version 1.0.0
      * @描述 通用返回类
      * @创建日期 2023/10/20
      * @since 1.0.0
      */
     @Data
     @AllArgsConstructor
     @NoArgsConstructor
     public class CommonResp<T> {
         private Integer code;
         private String message;
         private T data;
     
         /**
          * @param code
          * @param message
          * @return
          * @描述 有参构造，还可以设置方法返回this达到链式变成的效果
          * @author Earl
          * @version 1.0.0
          * @创建日期 2023/10/20
          * @since 1.0.0
          */
         public CommonResp(Integer code, String message){
             this(code,message,null);
         }
     }
     

2. 整合公共类、第三方接口、工具类等公共服务可以放在common模块下供各个服务调用

   该模块不对外提供接口，供各服务类调用

   常见整合的服务组件：dev-tool、lombok、hutool-all【糊涂工具包，处理时间日期格式】

   把公共类如entity【本人更倾向于vo、bo类】、工具类移动到该模块下，在其他模块中对该类进行引用

   xxxxxxxxxx
   <dependencies>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-devtools</artifactId>
           <scope>runtime</scope>
           <optional>true</optional>
       </dependency>
       <dependency>
           <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
           <optional>true</optional>
       </dependency>
       <dependency>
           <groupId>cn.hutool</groupId>
           <artifactId>hutool-all</artifactId>
           <version>5.1.0</version>
       </dependency>
   </dependencies>
   

• common模块创建之后要被其他模块使用需要用maven的mvn clean install先安装部署到本地仓库，再去各个子模块下的pom文件中引入

   

RestTemplate

RestTemplate是Spring提供的用于访问Rest服务的客户端模板工具集，是一种简单边界的访问restful服务模板类，对HttpClient进行了封装，提供多种便捷访问远程Http服务的方法【类似于JDBCTemplate和redisTemplate】

RestTemplate的官方文档：https://docs.spring.io/spring-framework/docs/5.2.2.RELEASE/javadoc-api/org/springframework/web/client/RestTemplate.html

1. RestTemplate的使用

   • 使用RestTemplate访问restful接口仅需三个参数

     • url：REST请求地址

     • requestMap：请求参数

     • ResponseBean.class：HTTP响应转换被转换成的对象类型

   • 使用RestTemplate需要向容器中进行注入

     xxxxxxxxxx
     @Configuration
     public class ApplicationContextConfig {
         /**
          * @return {@link RestTemplate }
          * @描述 注入RestTemplate对象
          * @author Earl
          * @version 1.0.0
          * @创建日期 2023/10/20
          * @since 1.0.0
          */
         @Bean
         public RestTemplate getRestTemplate(){
             return new RestTemplate();
         }
     }
     

   • RestTemplate的API

     注意：只要调用端Order服务封装响应数据类和被调用端响应数据类的全限定类名和类结构相同，数据就会被自动传递封装成对应类型；经过测试名字不同，包名不同，结构相同一样能够封装完整数据

     RestTemplate的post提交被调用方的对应参数必须使用@RequestBody注解：使用RestTemplate的post方式请求插入数据，如果被请求方法的参数没有@RequestBody注解修饰是无法获取到传递过去的请求参数的

     RestTemplate还有很多方法，慢慢总结吧

     xxxxxxxxxx
     @RestController
     @Slf4j
     public class OrderController {
         public static final String PAYMENT_URL="http://localhost:8001";
     
         @Resource
         private RestTemplate restTemplate;
     
         /**
          * @param payment
          * @return {@link CommonResp }<{@link Payment }>
          * @描述 01.RestTemplate发送post请求对其他服务进行调用，参数以对象的形式传入
          * @author Earl
          * @version 1.0.0
          * @创建日期 2023/10/20
          * @since 1.0.0
          */
         @PostMapping("/consumer/payment/create")
         public CommonResp<Payment> create(Payment payment){
             return restTemplate.postForObject(PAYMENT_URL+"/payment/create",payment,CommonResp.class);
         }
     
         /**
          * @param id
          * @return {@link CommonResp }<{@link Payment }>
          * @描述 02.RestTemplate发送Get请求对其他服务进行调用，参数直接拼接在url尾部
          * @author Earl
          * @version 1.0.0
          * @创建日期 2023/10/20
          * @since 1.0.0
          */
         @GetMapping("/consumer/payment/get/{id}")
         public CommonResp<Payment> getPayment(@PathVariable Long id){
             return restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id,CommonResp.class);
         }
     }
     

   • RestTemplate的post提交

     使用RestTemplate的post方式由服务发送的请求被调用方的参数必须有@RequestBody注解参数才能被获取封装，否则获取不到参数，数据库插入null，但是服务器不报错

     注意，即便调用方是Get请求只要能封装成Payment对象，也不影响调用方对RestTemplate的Post请求参数的接收，就是完全可以调用方接收get请求的参数，然后封装数据单独发送post请求给被调用方

     【调用方】

     xxxxxxxxxx
     @PostMapping("/consumer/payment/create")
     public CommonResponse<Payment> create(Payment payment){
         return restTemplate.postForObject(PAYMENT_URL+"/payment/create",payment, CommonResponse.class);
     }
     

     【被调用方】

     xxxxxxxxxx
     @PostMapping("/payment/create")
     public CommonResp create(@RequestBody Payment payment){
         int result=paymentService.create(payment);
         log.info("插入结果："+result);
         return result>0?new CommonResp(200,"数据插入成功",result):
                 new CommonResp(505,"插入数据库失败");
     }
     

     【添加@RequestBody注解前后效果】

     

服务注册与发现

Eureka

重点：分布式CAP理论

Eureka虽然官网停止更新，但是大部分老项目还在使用，

1. Eureka简介

   • SpringCloud封装了Netflix公司开发的Eureka模块来实现服务治理，

   • 服务注册与发现

     • Eureka Server作为服务注册功能的服务器是服务注册中心，系统中的其他微服务使用Eureka的客户端连接到Eureka Server并维持心跳连接，系统的维护人员通过Eureka Server来监控系统中各个微服务是否正常工作

     • 服务器启动时会把服务器信息，如服务通讯地址，服务器信息以别名的方式注册到注册中心，消费者以该别名去注册中心获取到实际的服务通讯地址，再实现本地RPC远程调用；

     • 核心在于用注册中心管理服务与服务的依赖关系，任何RPC远程框架都会有一个用于存放服务接口地址相关的信息

     • 服务调用者的访问对象可能是注册中心集群，也可能是服务提供者集群，避免单点故障造成系统挂掉；Dubbo的注册中心是Zookeeper

2. 整个服务注册和服务发现的流程

   • 服务提供者支付服务启动时将服务器信息【地址别名】注入Eureka服务器

   • 消费者订单服务【调用者是不是可以不注册，只开发拉取服务提供者信息功能即可】使用服务别名去注册中心获取实际的RPC远程调用地址

   • 消费者获取调用地址后，利用HttpClient技术实现远程调用

   • 消费者获取服务地址后会将服务地址缓存在本地JVM内存中，每隔30秒更新一次服务调用地址

3. Eureka的两个组件

   • Eureka Server：提供服务注册服务

     各微服务节点启动后会在Eureka Server中注册，其中的服务注册表会存储所有可用服务节点的信息，该信息可以在界面中直观看到

     服务注册：将服务信息注册进注册中心

     服务发现：从注册中心上获取服务信息

     实质就是将服务信息以key【服务名】-value【调用地址】键值对的方式将服务信息进行存储

   • Eureka Client：通过注册中心访问

     是一个用于简化Eureka Server交互的Java客户端，该客户端具备一个内置的、使用轮询负载算法的负载均衡器，应用启动阶段会以30s为周期向Eureka Server发送心跳，如果Eureka Server在多个心跳周期内【默认是90s】没有接收到某个节点的心跳，EurekaServer会自动将该服务节点从服务注册中心中将该节点移除

Eureka单机构建

构建Eureka单个服务器作为订单模块和支付模块的注册中心

1. 构建步骤：

   module--pom--yml--启动类--业务类

   服务结构

   

   • pom.xml

     需要引入netflix-eureka-server依赖，这玩意儿单指Eureka Server，client貌似是在各个微服务中安装的

     xxxxxxxxxx
     <dependencies>
         <!--eureka-server:Eureka服务器-->
         <dependency>
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
         </dependency>
         <!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
         <dependency>
             <groupId>com.atlisheng</groupId>
             <artifactId>03-common</artifactId>
             <version>${project.version}</version>
         </dependency>
         <!--boot web actuator-->
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
         <!--actuator用於图形监控，swagger和豪猪哥都要用到这个-->
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-actuator</artifactId>
         </dependency>
         <!--一般通用配置-->
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-devtools</artifactId>
             <scope>runtime</scope>
             <optional>true</optional>
         </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
         </dependency>
     </dependencies>
     

   • application.yml

     xxxxxxxxxx
     server:
       port: 7001
     
     eureka:
       instance:
         hostname: localhost #eureka服务端的实例名称，会用于其他服务对Eureka Server的访问，用于指定Eureka服务器的ip
       client:
         #register-with-eureka为false表示不想注册中心注册自己，默认就是false
         register-with-eureka: false
         #fetch-registry为false表示自己端就是注册中心，职责是维护服务实例，不需要去检索查询调用服务
         fetch-registry: false
         service-url:
           #设置与Eureka Server交互的地址，查询服务和注册服务都需要该地址
           defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
     

   • 启动类

     xxxxxxxxxx
     @SpringBootApplication
     @EnableEurekaServer//使用@EnableEurekaServer注解标注该启动类为服务注册中心，不需要写其他的业务代码，Eureka会自动执行相关组件管理服务
     public class EurekaApplication {
         public static void main(String[] args){
             SpringApplication.run(EurekaApplication.class,args);
         }
     }
     

   • 前端页面

     DS Replicas指的是在该Eureka服务器上注册的其他Eureka服务器

     

2. 将微服务配置到Eureka单机服务器中

   • 在微服务中引入Eureka Client的依赖

     xxxxxxxxxx
     <!--老版本使用spring-cloud-starter-eureka-->
     <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-eureka</artifactId>
     </dependency>
     
     <!--H版使用netflix-eureka-client-->
     <!--eureka-server:Eureka服务器-->
     <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
     </dependency>
     

   • 在每个微服务配置类中添加对Eureka的配置

     Eureka的配置太多，客户端和服务端都要用户创建和配置，是否抓取和注册都要在每个服务器中注册，不好统一管理且配置麻烦，导致Eureka被Nacos替代，而且调用服务的代码全部写了一大坨在控制器方法中，脱离了封装的初衷

     xxxxxxxxxx
     #eureka配置信息
     eureka:
       client:
         #将当前服务注册到EurekaServer中
         register-with-eureka: true
         #从EurekaServer抓取已有注册信息，默认为true，单节点无所谓，集群必须设置为true配合ribbon使用负载均衡
         fetch-registry: true
         service-url:
           defaultZone: http://localhost:7001/eureka
     

   • 在每个微服务启动类上使用@EnableEurekaClient注解

     xxxxxxxxxx
     @SpringBootApplication
     @EnableEurekaClient
     public class OrderApplication {
         public static void main(String[] args){
             SpringApplication.run(OrderApplication.class,args);
         }
     }
     

     xxxxxxxxxx
     @SpringBootApplication
     @EnableEurekaClient
     public class PaymentApplication {
         public static void main(String[] args) {
             SpringApplication.run(PaymentApplication.class,args);
         }
     }
     

3. Eureka Server的访问地址中出现对应的微服务列表，即配置成功

    

    

    

Eureka集群构建

没有服务集群的高可用一定会带来单点故障的问题【nginx和redis中讲过】

微服务RPC远程服务调用最核心的是高可用，单机Eureka爆炸整个服务系统都会不可用

解决高可用问题的办法就是搭建Euraka注册中心集群，实现负载均衡和故障容错

一般三个服务中心就顶天了

Eureka集群架构的重点是Eureka Server集群对外暴露为Eureka服务器整体，内部相互注册【在本机上记录其他Eureka服务器信息】，服务集群对外暴露服务名，不需要指定特定的ip和端口，通过集群服务名和RestTemplate的@LoadBanlanced实现服务调用和默认轮询的负载均衡策略

1. 构建原理

   • 对外统一被称作Eureka，内部机器相互注册【本台机器一定要有Eureka集群中其他机器的服务器信息】，对外暴露组成一个整体

2. 构建步骤

   • 参考7001Eureka Server再创建一个7002Eureka Server

   • 修改映射配置：在c:\windows\System32\drivers\etc\hosts文件中添加配置映射到hosts文件中，方便区分

     原因是单机情况下localhost对应一台，集群情况下，用一台机器模拟修改映射能更加方便区分【？不改可以吗】，多台Eureka服务器相应配置多台，改了之后使用localhost不使用映射同样可以访问

     xxxxxxxxxx
     127.0.0.1 eureka7001.com
     127.0.0.1 eureka7002.com
     

   • 修改两个Eureka Server的yml文件配置，达到相互注册的效果

     单机版写法：地址查询和注册服务依赖的地址填写的自身

     集群版写法：hostname更改为在windows中映射配置的名字，在defaultZone属性添加其他Eureka服务器地址，超过三台通过逗号分隔配置

     xxxxxxxxxx
     server:
       port: 7001
     
     eureka:
       instance:
         hostname: eureka7001.com #eureka服务端的实例名称，会用于其他服务对Eureka Server的访问，用于指定Eureka服务器的ip
       client:
         #register-with-eureka为false表示不想注册中心注册自己，默认就是false
         register-with-eureka: false
         #fetch-registry为false表示自己端就是注册中心，职责是维护服务实例，不需要去检索查询调用服务
         fetch-registry: false
         service-url:
           #设置与Eureka Server交互的地址，查询服务和注册服务都需要该地址,单机Eureka交互地址指向自己
           #defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
           #Eureka集群交互地址指向集群中的其他兄弟
           defaultZone: http://eureka7002.com:7002/eureka/
           #超过三台Eureka服务器直接通过逗号分隔其他Eureka服务器地址
           #defaultZone: http://eureka7002.com::${server.port}/eureka/,http://eureka7003.com::${server.port}/eureka/
     

     xxxxxxxxxx
     server:
       port: 7002
     
     eureka:
       instance:
         hostname: eureka7002.com #eureka服务端的实例名称，会用于其他服务对Eureka Server的访问，用于指定Eureka服务器的ip
       client:
         #register-with-eureka为false表示不想注册中心注册自己，默认就是false
         register-with-eureka: false
         #fetch-registry为false表示自己端就是注册中心，职责是维护服务实例，不需要去检索查询调用服务
         fetch-registry: false
         service-url:
           #设置与Eureka Server交互的地址，查询服务和注册服务都需要该地址
           #defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
           defaultZone: http://eureka7001.com:7001/eureka/
     
     

   • 启动Eureka服务器集群并测试

     注意关闭梯子，有梯子只能通过localhost进行访问，无法通过别名映射访问

     

3. 将微服务配置到Eureka集群中

   • 在每个微服务中引入netflix-eureka-client依赖

   • 修改微服务配置文件的defaultZone查询服务地址，注册地址为全体Eureka服务器，用逗号进行分隔

     只需要修改defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka

     xxxxxxxxxx
     server:
       port: 80 #用户支付下订单的模块用户不应该关心输入哪个端口进行访问，浏览器网页服务的默认端口都是80，只需要输入网址，不需要输入:80,提升用户体验
     
     #eureka配置信息
     eureka:
       client:
         #将当前服务注册到EurekaServer中
         register-with-eureka: true
         #从EurekaServer抓取已有注册信息，默认为true，单节点无所谓，集群必须设置为true配合ribbon使用负载均衡
         fetch-registry: true
         service-url:
           #defaultZone: http://localhost:7001/eureka
           #集群版
           defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
     

     xxxxxxxxxx
     server:
       port: 8001
     
     spring:
       application:
         name: service-payment
       datasource:
         type: com.alibaba.druid.pool.DruidDataSource
         driver-class-name: com.mysql.cj.jdbc.Driver
         url: jdbc:mysql://localhost:3306/cloud_h_demo?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8&useSSL=false
         password: Haworthia0715
         username: root
     
     mybatis:
       mapper-locations: classpath:mapper/*.xml
       #所有entities所在的包
       type-aliases-package: com.atlisheng.cloud.entities
     
     #eureka配置信息
     eureka:
       client:
         #将当前服务注册到EurekaServer中
         register-with-eureka: true
         #从EurekaServer抓取已有注册信息，默认为true，单节点无所谓，集群必须设置为true配合ribbon使用负载均衡
         fetch-registry: true
         service-url:
           #集群版
           defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
     

   • 在每个微服务启动类上使用@EnableEurekaClient注解

     不写这个注解也能显示在Eureka服务列表中，经过测试

4. 测试

   • 项目启动时，先启动Eureka集群，再启动服务提供者provider，最后启动消费者consumer

   • 测试服务调用没问题

   • 效果

     

     

Eureka负载均衡

创建06-provider-payment组成支付服务集群测试Eureka负载均衡：Eureka默认的负载均衡策略就是轮询

当访问指定端口号服务器不走Eureka，访问对应的服务器；

如果使用调用者走Eureka对服务进行调用【注意要将调用服务的url的ip:port【http://localhost:8001】部分统一改成服务名称【http://service-payment】，即服务集群的url不能写死到端口，会导致只有固定端口的服务进行工作，无法达到负载均衡的效果】，服务对被调用者暴露为微服务名，同时必须在RestTemplate注入类上添加@LoadBalanced注解赋予RestTemplate负载均衡的能力，此时配置微服务名的服务集群调用才能生效

Ribbon和Eureka整合后消费者可以直接调用服务而不用关心地址和端口号，且整合了负载均衡的功能【默认轮询】

关键：

• 服务集群的url认服务名不认ip:端口，把ip和端口写死只能访问单个服务，必须写成http://服务名的形式是负载均衡的前提之一

• 必须在RestTemplate的注入方法上添加@LoadBalanced注解开启默认负载均衡策略

1. 配置消费者调用服务的url

   xxxxxxxxxx
   //public static final String PAYMENT_URL="http://localhost:8001";
   public static final String PAYMENT_URL="http://server-payment";
   
   @Resource
   private RestTemplate restTemplate;
   
   /**
    * @param payment
    * @return {@link CommonResp }<{@link Payment }>
    * @描述 RestTemplate发送post请求对其他服务进行调用，参数以对象的形式传入
    * @author Earl
    * @version 1.0.0
    * @创建日期 2023/10/20
    * @since 1.0.0
    */
   @PostMapping("/consumer/payment/create")
   public CommonResp<Payment> create(Payment payment){
       return restTemplate.postForObject(PAYMENT_URL+"/payment/create",payment, CommonResp.class);
   }
   

2. 配置消费者的RestTemplate的@LoadBalanced注解开启默认负载均衡策略

   这里用到的就是Ribbon的负载均衡功能，默认的策略就是轮询

   xxxxxxxxxx
   @Configuration
   public class ApplicationContextConfig {
       /**
        * @return {@link RestTemplate }
        * @描述 注入RestTemplate对象
        * @author Earl
        * @version 1.0.0
        * @创建日期 2023/10/20
        * @since 1.0.0
        */
       @Bean
       @LoadBalanced
       public RestTemplate getRestTemplate(){
           return new RestTemplate();
       }
   }
   

3. 测试

   • 通过http://localhost/consumer/payment/get/3在不同服务器同一个方法交替输出对应端口号信息展示出对应的轮询负载均衡策略

Actuator微服务信息完善

Actuator可以完善微服务信息，包括主机名称，访问信息IP提示等，可以不配置，配置以后看着更舒服

spring-boot-starter-web和spring-boot-starter-actuator是标配，一般一起进行导入，使用actuator对ip，端口等信息进行完善

1. Eureka的服务列表的status字段会显示主机名:集群服务名，使用Actuator设置去掉主机名【并配置自定义服务名称】

   在微服务配置文件中添加属性eureka.instance.instance-id=自定义主机服务名字【一般都设置为服务名称:端口，ip信息在鼠标悬停浮动展示】

   xxxxxxxxxx
   #eureka配置信息
   eureka:
     instance:
       #actuator设置服务列表Status服务名
       instance-id: order80
   

2. 服务器布置多了以后需要关注机器编号、服务端口、服务类型

   在微服务配置文件中添加属性eureka.instance.prefer-ip-address=true，实现鼠标悬停服务器展示ip和端口的效果

   xxxxxxxxxx
   #eureka配置信息
   eureka:
     instance:
       #actuator设置服务列表Status服务鼠标悬停浏览器左下角显示ip和端口
       prefer-ip-address: true
   

服务信息主动访问

通过DiscoveryClient对象可以主动获取并在程序中使用微服务主动注册在注册中心的服务信息，DiscoveryClient对象不要用@Autowire注解和@quelifier注解注入，只能使用@Resource进行注入，否则会报空指针

留意一下服务发现是什么概念，DiscoveryClient对服务注册信息访问时通过服务发现实现的

设置方式：

• 使用DiscoveryClient对象需要对应导入 org.springframework.cloud.client.discovery.DiscoveryClient包，不要导入网飞的那个包

• 在访问各个微服务信息的服务中的启动类上添加@EnableDiscoveryClient注解，在服务中调用以下方法获取所有微服务信息

  • 注意@EnableEurekaClient几乎不咋用了，但是@EnableDiscoveryClient除了服务发现还有很多其他功能

1. discoveryClient.getServices()：获取微服务列表的所有服务集群名称，返回字符串list集合

2. discoveryClient.getInstances(String serviceName)：通过服务集群的名字获取一个服务集群的服务实例列表，返回ServiceInstance类型的List集合

   • serviceInstance.getServiceId()：获取所属服务集群名称

   • serviceInstance.getInstanceId()：获取单个服务实例自定义名称

   • serviceInstance.getHost()：获取微服务所在主机ip

   • serviceInstance.getPort()：获取微服务所在端口

   • serviceInstance.getUri()：获取微服务访问Uri【协议://ip:端口】

   • serviceInstance.getScheme()：不知道Scheme是什么

   • serviceInstance.getClass()：获取单个微服务实例的数据封装类型【貌似是动态代理类】

   xxxxxxxxxx
   @GetMapping("/payment/services")
   public Object getServices(){
       List<String> services = discoveryClient.getServices();
       for (String service:services) {
           List<ServiceInstance> instances = discoveryClient.getInstances(service);
           String serviceList=new String();
           for (ServiceInstance instance:instances) {
               serviceList=serviceList+
                       instance.getServiceId()+"\t"+
                       instance.getInstanceId()+"\t"+
                       instance.getHost()+"\t"+
                       instance.getPort()+"\t"+
                       instance.getUri()+"\t"+
                       instance.getScheme()+"\t"+
                       instance.getMetadata()+"\t"+
                       instance.getClass();
           }
           log.info("serviceName:"+service+"|serviceList:"+serviceList);
       }
       return this.discoveryClient;
   }
   

   【log.info输出信息】

   xxxxxxxxxx
   2023-10-23 18:09:53.434  INFO 13376 --- [nio-8003-exec-6] c.a.cloud.controller.PaymentController   : 
   serviceName:service-payment|
   serviceList:
       SERVICE-PAYMENT 
       payment8002 
       192.168.0.104   
       8003    
       http://192.168.0.104:8003   
       null    
       {management.port=8003}  
       class org.springframework.cloud.netflix.eureka.EurekaDiscoveryClient$EurekaServiceInstance
       
       SERVICE-PAYMENT 
       payment8001 
       192.168.0.104   
       8001    
       http://192.168.0.104:8001   
       null    
       {management.port=8001}  
       class org.springframework.cloud.netflix.eureka.EurekaDiscoveryClient$EurekaServiceInstance
   
   2023-10-23 18:09:53.434  INFO 13376 --- [nio-8003-exec-6] c.a.cloud.controller.PaymentController   : 
   serviceName:service-order|
       serviceList:
           SERVICE-ORDER   
           order80 
           192.168.0.104   
           80  
           http://192.168.0.104:80 
           null    
           {management.port=80}    
           class org.springframework.cloud.netflix.eureka.EurekaDiscoveryClient$EurekaServiceInstance
   

3. discoveryClient所具备的所有信息

   实际应该更加丰富，只是这里调用了toString方法，把属性处理成了服务名；【实际有很多东西，debug看都看不懂】

   order是表示排序的，不用管

   xxxxxxxxxx
   {
     "services": [
       "service-payment",
       "service-order"
     ],
     "order": 0
   }
   

    

Eureka自我保护

Eureka界面出现EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY'RE NOT. RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE.说明Eureka进入了保护模式

保护模式主要用于一组客户端和Eureka Server建存在网络分区场景下的保护【某时刻一个微服务可能因为网络延迟等原因监测不到微服务实例的心跳包，Eureka不会立刻清理，依旧会对该微服务的信息进行保存，如果能恢复过来就继续正常使用，是一种高可用的设计思想，属于分布式CAP理论中的AP分支，这里是不是AP理论有异议】，进入保护模式后Eureka Server会尝试保护服务注册表中的信息，不再删除服务注册表中的数据，即不会注销任何微服务；

1. Eureka自我保护是为了避免EurekaClient运行正常但是与Eureka Server网络不同情况下Eureka服务器立即将Eureka Client剔除

   • EurekaServer默认在90s内没有接收到微服务实例的心跳，就会注销该实例，但是如果网络分区发生故障【延迟、卡顿、拥挤】，但是此时微服务本身是健康的，此时不应该注销该微服务，

   • Eureka用自我保护模式来解决该问题，当Eureka短时间失去过多客户端时会认为可能发生了网络分区故障，相关节点会进入自我保护模式，涉及思想就是宁可保留错误的服务注册信息，也不盲目注销任何可能健康的服务实例，目的就是为了高可用，同时也是Eureka集群更加健壮、稳定

2. Eureka默认是开始自我保护的，可以设置禁止自我保护机制

   即实现只要90s检测不到心跳包，就立刻注销对应微服务

   • 第一步：在Eureka Server的配置文件中设置eureka.server.enable-self-preservation=false【输入属性名看提示能发现默认是开启的】

     关了以后Eureka界面会提示安全模式已经被关闭

   • 第二步：在Eureka Server的配置文件中设置eureka.server.eviction-interval-timer-in-ms=2000，默认是90s 【设置注销服务时间间隔设置成2s】

     【Eureka服务端设置】

     xxxxxxxxxx
     eureka:
       server:
         #关闭Eureka服务端自我保护机制
         enable-self-preservation: false
         #Eureka服务端在收到最后一次心跳后的等待时间上限，单位为毫秒（默认是90s），超时将剔除服务
         eviction-interval-timer-in-ms: 2000
     

   • 第三步：eureka.client.instance.lease-renewal-interval-in-seconds=1设置Eureka Client向服务端发送心跳包的时间间隔为1s，默认是30s【单位为秒】

   • 第四步：eureka.client.instance.lease-expiration-duration-in-seconds=2设置Eureka客户端在收到最后一次心跳后等待时间上限，单位为秒

     【Eureka客户端即微服务中的设置】

     讲的不清楚啊，就讲了要这么配，但是配来干什么就得猜，尚硅谷的课都是这个毛病

     xxxxxxxxxx
     #eureka配置信息
     eureka:
       instance:
         #Eureka客户端向服务端发送心跳的时间间隔
         lease-renewal-interval-in-seconds: 1
         #Eureka服务端在收到最后一次心跳后的等待时间上限，单位为秒（默认是90s），超时将剔除服务
         lease-expiration-duration-in-seconds: 2
     

3. 测试：配置了以上心跳时间、最后一次心跳等待上限和关闭保护模式后的测试效果

   • 客户端心跳包时间间隔1s，等待上限2s，开启两个服务，服务列表正常显示

   • 关闭客户端服务，Eureka服务端的服务列表立刻删除了对应客户端

   • 将客户端发送心跳的时间设置成3s，Eureka等待时间上限设置成2s，测试一下

     经过测试，心跳包发送间隔略大于等待上限时间，服务仍然能够正常显示，且第三方服务能通过Eureka对该服务进行调用

Zookeeper替换Eureka

创建模块07

1. Eureka停更说明

   Eureka2.0以后停止了更新，使用Eureka2.x导致的风险自己负责，Eureka1.0作为网飞服务发现系统仍然是一个活跃的工程

   部分企业老项目是Zookeeper+Dubbo，想要最小代价切换Dubbo到SpringCloud，就需要使用到SpringCloud整合Zookeeper替代Eureka，可以实现最小代价更换项目架构

2. SpringCloud整合Zookeeper替代Eureka

   • Zookeeper是一个分布式协调工具，可以实现注册中心的功能，原本是Dubbo的注册中心

   • 本次Zookeeper3.4.9，装载Linux系统上，记得开放防火墙远程通讯端口【学Zookeeper时留意一下linux系统ping通windows系统时的windows系统的ip如何获取】

     这里暂时只开放了2181端口

   • 使用ipconfig命令查出windows系统的ip地址

     

   • 使用ifconfig命令查看linux系统的ip地址

     

   • 使用ping命令测试windows和linux是否能够ping通

   • 在目标微服务的pom文件中添加spring-cloud-starter-zookeeper-discovery依赖

     引入了Zookeeper，Eureka的依赖必须注释或者排除掉，否则项目无法启动

     Zookeeper依赖的版本必须和Zookeeper集群中的版本对应

     

     xxxxxxxxxx
     <dependencies>
         <!--eureka-client-->
         <!--使用ZookeeperEureka需要排除掉，因为没有配置-->
         <!--<dependency>
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
         </dependency>-->
         <!--spring-boot-->
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
         <dependency>
             <groupId>org.mybatis.spring.boot</groupId>
             <artifactId>mybatis-spring-boot-starter</artifactId>
         </dependency>
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>druid-spring-boot-starter</artifactId>
             <version>1.1.10</version>
         </dependency>
         <!--mysql-connector-java-->
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
         </dependency>
         <!--jdbc-->
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-jdbc</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-devtools</artifactId>
             <scope>runtime</scope>
             <optional>true</optional>
         </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
             <optional>true</optional>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>com.atlisheng</groupId>
             <artifactId>03-common</artifactId>
             <version>${project.version}</version>
         </dependency>
         <!--springBoot整合Zookeeper客户端-->
         <dependency>
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
             <!--排除掉上述jar包中的Zookeeper3.5.3-->
             <exclusions>
                 <exclusion>
                     <groupId>org.apache.zookeeper</groupId>
                     <artifactId>zookeeper</artifactId>
                 </exclusion>
             </exclusions>
         </dependency>
         <!--引入本机安装的Zookeeper3.5.7版本-->
         <dependency>
             <groupId>org.apache.zookeeper</groupId>
             <artifactId>zookeeper</artifactId>
             <version>3.5.7</version>
         </dependency>
     </dependencies>
     

   • 启动类

     zookeeper服务端和客户端均运行在linux系统中，使用consul或者Zookeeper作为注册中心时微服务向注册中心进行注册启动类上均使用@EnableDiscoveryClient注解

     而Eureka的服务器启动类上标注@EnableEurekaServer，客户端微服务启动类上标注@EnableEurekaClient

     xxxxxxxxxx
     @SpringBootApplication
     @EnableDiscoveryClient//该注解用于向使用consul或者Zookeeper作为注册中心时微服务向注册中心进行注册
     public class PaymentApplication {
         public static void main(String[] args){
             SpringApplication.run(PaymentApplication.class,args);
         }
     }
     

   • 配置文件application.yml

     xxxxxxxxxx
     #注册到Zookeeper服务器中的支付服务的服务器端口号
     server:
       port: 8004
     #数据元
     spring:
       datasource:
         type: com.alibaba.druid.pool.DruidDataSource
         driver-class-name: com.mysql.cj.jdbc.Driver
         url: jdbc:mysql://localhost:3306/cloud_h_demo?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true
         password: Haworthia0715
         username: root
     #服务别名--注册Zookeeper服务注册中心列表的名称
       application:
         name: cloud-provider-payment
       cloud:
         zookeeper:
           #一个Zookeeper的ip+端口号
           connect-string: 192.168.200.132:2181
     

   • controller

     就整合Zookeeper来说，这个没啥意义，只是证明能够正常访问

     xxxxxxxxxx
     @RestController
     @Slf4j
     public class PaymentController {
         @Value("${server.port}")
         private String serverPort;
     
         @GetMapping("/payment/zk")
         public String paymentRegistryByZk(){
             log.info("slf4j是否正常");
             return "Registry with zookeeper:"+serverPort+"\t"+ UUID.randomUUID().toString();
         }
     }
     

   • Zookeeper的服务器注册信息

     xxxxxxxxxx
     #服务启动前，只有一个Zookeeper节点
     [zk: localhost:2181(CONNECTED) 1] ls /
     [zookeeper]
     #显示Zookeeper节点下的信息
     [zk: localhost:2181(CONNECTED) 3] ls /zookeeper
     [config, quota]
     
     #服务启动后在Zookeeper中出现服务列表
     [zk: localhost:2181(CONNECTED) 9] ls /
     [services, zookeeper]
     #列表下展示的是在注册中心注册的服务名
     [zk: localhost:2181(CONNECTED) 10] ls /services
     [cloud-provider-payment]
     #585ddd0b-7d30-4225-afda-758f05b75c8f是Zookeeper自己生成的uuid
     [zk: localhost:2181(CONNECTED) 11] ls /services/cloud-provider-payment
     [585ddd0b-7d30-4225-afda-758f05b75c8f]
     [zk: localhost:2181(CONNECTED) 12] ls /services/cloud-provider-payment/585ddd0b-7d30-4225-afda-758f05b75c8f
     []
     #获取Zookeeper中被注册服务的注册信息
     [zk: localhost:2181(CONNECTED) 13] get /services/cloud-provider-payment/585ddd0b-7d30-4225-afda-758f05b75c8f
     {"name":"cloud-provider-payment","id":"585ddd0b-7d30-4225-afda-758f05b75c8f","address":"192.168.0.106","port":8004,"sslPort":null,"payload":{"@class":"org.springframework.cloud.zookeeper.discovery.ZookeeperInstance","id":"application-1","name":"cloud-provider-payment","metadata":{}},"registrationTimeUTC":1698197224917,"serviceType":"DYNAMIC","uriSpec":{"parts":[{"value":"scheme","variable":true},{"value":"://","variable":false},{"value":"address","variable":true},{"value":":","variable":false},{"value":"port","variable":true}]}}
     

   • 服务注册信息【json字符串】

     使用网站https://tool.lu/json可以转换json字符串为json工具

     xxxxxxxxxx
     {
       "name": "cloud-provider-payment",
       "id": "585ddd0b-7d30-4225-afda-758f05b75c8f",
       "address": "192.168.0.106",
       "port": 8004,
       "sslPort": null,
       "payload": {
         "@class": "org.springframework.cloud.zookeeper.discovery.ZookeeperInstance",
         "id": "application-1",
         "name": "cloud-provider-payment",
         "metadata": {}
       },
       "registrationTimeUTC": 1698197224917,
       "serviceType": "DYNAMIC",
       "uriSpec": {
         "parts": [
           {
             "value": "scheme",
             "variable": true
           },
           {
             "value": "://",
             "variable": false
           },
           {
             "value": "address",
             "variable": true
           },
           {
             "value": ":",
             "variable": false
           },
           {
             "value": "port",
             "variable": true
           }
         ]
       }
     }
     

3. zookeeper的节点

   Zookeeper的节点分为临时节点、带序号的临时节点、持久节点、带序号的持久节点

   • 服务器注册在Zookeeper上的节点是临时节点，只要服务器挂了，Zookeeper接收不到来自服务器的心跳，出了默认时间就直接删除服务器的注册信息，不像Eureka一样默认有自我保护机制；重新启动服务器以后向Zookeeper注册，此时Zookeeper中的对应uuid和之前的已经不一样了

4. 消费者服务注册到Zookeeper并通过Zookeeper调用支付模块

   Zookeeper区分服务名大小写，这里的演示代码中用的集群服务名的方式设置支付模块的url，如果是Zookeeper集群只需要在配置文件中将Zookeeper的地址写成集群方式，和Eureka集群一样用逗号进行分隔

   创建模块08作为注册Zookeeper的消费者模块

   • pom.xml

     zookeeper的依赖版本要和linux上的Zookeeper版本严格对应

     xxxxxxxxxx
     <dependencies>
         <!--spring-boot-->
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
         <!--数据库相关配置-->
         <dependency>
             <groupId>org.mybatis.spring.boot</groupId>
             <artifactId>mybatis-spring-boot-starter</artifactId>
         </dependency>
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>druid-spring-boot-starter</artifactId>
             <version>1.1.10</version>
         </dependency>
         <!--mysql-connector-java-->
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
         </dependency>
         <!--jdbc-->
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-jdbc</artifactId>
         </dependency>
         <!--开发工具热部署-->
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-devtools</artifactId>
             <scope>runtime</scope>
             <optional>true</optional>
         </dependency>
         <!--日志，getter和setter-->
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
             <optional>true</optional>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>com.atlisheng</groupId>
             <artifactId>03-common</artifactId>
             <version>${project.version}</version>
         </dependency>
         <!--springBoot整合Zookeeper客户端-->
         <dependency>
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
             <!--排除掉上述jar包中的Zookeeper3.5.3-->
             <exclusions>
                 <exclusion>
                     <groupId>org.apache.zookeeper</groupId>
                     <artifactId>zookeeper</artifactId>
                 </exclusion>
             </exclusions>
         </dependency>
         <!--引入本机安装的Zookeeper3.5.7版本-->
         <dependency>
             <groupId>org.apache.zookeeper</groupId>
             <artifactId>zookeeper</artifactId>
             <version>3.5.7</version>
         </dependency>
     </dependencies>
     

   • application.yml

     xxxxxxxxxx
     #注册到Zookeeper服务器中的支付服务的服务器端口号
     server:
       port: 80
     #数据元
     spring:
       datasource:
         type: com.alibaba.druid.pool.DruidDataSource
         driver-class-name: com.mysql.cj.jdbc.Driver
         url: jdbc:mysql://localhost:3306/cloud_h_demo?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true
         password: Haworthia0715
         username: root
     
       #服务别名--注册Zookeeper服务注册中心列表的名称
       application:
         name: cloud-consumer-order
       cloud:
         zookeeper:
           #一个Zookeeper的ip+端口号
           connect-string: 192.168.200.132:2181
     

   • 启动类

     xxxxxxxxxx
     @SpringBootApplication
     @EnableDiscoveryClient
     public class OrderApplication {
         public static void main(String[] args){
             SpringApplication.run(OrderApplication.class,args);
         }
     }
     

   • 配置类

     没学Ribbon以前还是使用RestTemplate进行服务调用【封装了HttpClient】

     xxxxxxxxxx
     @Configuration
     public class ApplicationContextConfig {
         /**
          * @return {@link RestTemplate }
          * @描述 注入RestTemplate对象
          * @author Earl
          * @version 1.0.0
          * @创建日期 2023/10/20
          * @since 1.0.0
          */
         @Bean
         @LoadBalanced
         public RestTemplate getRestTemplate(){
             return new RestTemplate();
         }
     }
     

   • controller

     xxxxxxxxxx
     @RestController
     @Slf4j
     public class OrderController {
         //Zookeeper的服务名严格区分大小写，Eureka不区分
         public static final String PAYMENT_URL="http://cloud-provider-payment";
     
         @Resource
         private RestTemplate restTemplate;
     
         /**
          * @return {@link String }
          * @描述 consumer注册到Zookeeper中，通过Zookeeper调用payment服务返回结果
          * @author Earl
          * @version 1.0.0
          * @创建日期 2023/10/25
          * @since 1.0.0
          */
         @GetMapping("/consumer/payment/zk")
         public String paymentInvokeByZk(){
             String result=restTemplate.getForObject(PAYMENT_URL+"/payment/zk",String.class);
             return result;
         }
     }
     

   • 测试效果